17_内部类和常用类

目录

• 一. 内部类
  • 1. 成员内部类
  • 2. 静态内部类
  • 3. 局部内部类
  • 4. 匿名内部类
• 二. 常用类
  • 1. Object
    • (1) getClass()方法
    • (2) hashCode()方法
    • (3) toString()方法
    • (4) equals()方法
    • (5) finalize()方法
  • 2. 包装类
  • 3. String
    • (1)常用方法
    • (2)StringBuffer和StringBuilder
  • 4.BigDecimal
  • 5. Date
  • 6. Calendar
  • 7.SimpleDateFormat
  • 8. System

一. 内部类

概念：

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

特点：

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

1. 成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
  • Outer out = new Outer();
  • Inner in = out.new Inner();
• 当外部类、内部类存在重名属性时，会优先访问内部类属性
• 成员内部类不能定义静态成员，但可以定义静态常量

2. 静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
  • Outer.Inner inner = new Outer.Inner();
  • Outer.Inner.show();

3. 局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
• 不能加任何访问修饰符
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final(jdk1.8以后隐式添加final)
• 限制类的使用范围

4. 匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或者实现一个接口
• 定义类、实现类、创建对象的语法合并、只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

二. 常用类

1. Object

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

(1) getClass()方法

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

(2) hashCode()方法

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

(3) toString()方法

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

(4) equals()方法

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

(5) finalize()方法

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

public class TestStudent {

    public static void main(String[] args) {

        System.out.println("=====getClass()方法=====");
        //1. getClass()方法
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);

        //判断s1和s2是否是同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("student和student1属于同一类型");//student和student1属于同一类型
        }else{
            System.out.println("student和student1不属于同一类型");
        }

        System.out.println("=====hashCode()方法=====");
        //2. hashCode()方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        Student s3=s1;
        System.out.println(s3.hashCode());

        System.out.println("=====toString()方法=====");
        //3. toString()方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());

        System.out.println("=====equals()方法=====");
        //4. equals()方法
        System.out.println(s1.equals(s2));
        Student s4 = new Student("王五", 20);
        Student s5 = new Student("王五", 20);
        System.out.println(s4.equals(s5));

    }
}

2. 包装类

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

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换

基本类型和引用类型

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

拆箱：引用类型转成基本类型的过程

public class Demo01 {

    public static void main(String[] args) {

        //JDK 1.5之前
        //类型转换
        //装箱：基本类型转成引用类型的过程
        int num = 10;
        Integer integer = new Integer(num);
        Integer integer1 =  Integer.valueOf(num);
        System.out.println("装箱");
        System.out.println(integer);
        System.out.println(integer1);
        //类型转换
        //拆箱：引用类型转成基本类型的过程
        Integer integer2 = new Integer(100);
        int num2 = integer2.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5之后，提供自动装箱和开箱功能
        int age = 30;
        //自动装箱
        Integer integer3 = age;
        System.out.println("自动装箱");
        System.out.println(integer3);
        //自动拆箱
        int age2 = integer3;
        System.out.println("自动拆箱");
        System.out.println(age2);

        //1. 基本类型转字符串
        //1.1 使用“+”
        int i = 255;
        int i1 = 1;
        System.out.println(i+i1+"");//256 字符串在后面，相加
        System.out.println(""+i+i1);//2551 字符串在前面，拼接
        String s = i + "";
        System.out.println(s);//255

        //1.2 Integer.toString()
        String s2 = Integer.toString(i);
        System.out.println(s2);//255
        //toString重载，输出i的radix进制数
        String s3 = Integer.toString(i, 16);
        System.out.println(s3);//ff

        //2. 字符串转基本类型
        String str = "100";
        //使用Integer.parseInt()
        int i2 = Integer.parseInt(str);
        System.out.println(i2);//100

        //boolean字符串形式转成基本类型，"true"=>true,只要不是"true",都是false
        String str2 = "true";
        boolean b = Boolean.parseBoolean(str2);
        System.out.println(b);//true
    }
}
折叠 

整数缓冲区（-128~127）

• java预先创建了256个常用的整数包装类型对象
• 在实际应用当中，对已创建的对象进行复用

public class Demo02 {

    public static void main(String[] args) {

        //Integer缓冲区-128~127
        Integer integer = new Integer(100);
        Integer integer1 = new Integer(100);
        System.out.println(integer == integer1);//false

        Integer integer2 = Integer.valueOf(100);
        Integer integer3 = Integer.valueOf(100);
        //在缓冲区里,值一样，引用对象也相同
        System.out.println(integer2 == integer3);//true

        Integer integer4 = Integer.valueOf(100);
        Integer integer5 = Integer.valueOf(100);
        //不在缓冲区里，则重新在堆里面new一个对象，所以两个不同的对象的引用也不同
        System.out.println(integer4 == integer5);//false
    }
}

3. String

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

常量池概念：

Java运行时会维护一个String Pool（String池）， 也叫“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。

String对象的创建很讲究，关键是要明白其原理。

原理1：当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个s在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。

原理2：Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。

原理3：使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

原理4：使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。最后指向堆内存中的对象

public class Demo01 {

    public static void main(String[] args) {

        //1. 先定义一个名为str的对String类的对象引用变量：String str；
        String str1 = "aaa";//字符串常量存储在方法区的字符串池中
        //2. 在池中查找有没有存放值为"aaa"的地址，如果没有，则开辟一个存放字面值为"aaa"的地址
        //接着创建一个新的String类的对象o，并将o 的字符串值指向这个地址，而且在池中这个地址旁边记下这个引用的对象o。如果已经有了值为"aaa"的地址，则查找对象o，并返回o的地址。
        //3. 将str指向对象o的地址
        //当我们将str1的值改为"bbb"时，JVM发现在池中没有存放该值的地址，便开辟了一个存放字面值为"bbb"的地址，并创建了一个新的对象，其字符串的值指向这个地址

        str1 = "bbb";

        String str2 = "bbb";//JVM 创建str2，并指向“bbb”
        System.out.println(str1 == str2);//true
        //总结就是：JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象

        //1、 使用new关键字

        String s1 = new String("ab"); //产生两个对象，堆、池中各存一个

        //2、 使用字符串常量直接赋值

        String s2 = "abc";

        //3、 使用”+”运算符进行字符串连接

        String s3 = "abc" + "d";

        String s4 = s3 + 5; //abcd5

        System.out.println("=======================");

        String n1 = new String("java");
        String n2 = new String("java");
        System.out.println(n1 == n2);//false,n1和n2分别指向堆中的两个对象
        System.out.println(n1.equals(n2));//true
    }
}
折叠 

(1)常用方法

- public int length()：返回字符串的长度
- public char charAt(int index)：根据下标获取字符
- public boolean contains(String str)：判断当前字符串是否包含str
- public char[] toCharArray()：将字符串转化为数组
- public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
- public int lastIndexOf(String str)：查找str最后一次出现的下标索引
- public String trim()：去掉字符串前后的空格
- public String toUpperCase()：将小写转成大写
- public boolean endWith(String str)：判断字符串是否以str结尾
- public String replace(char oldChar,char newChar):将旧字符串替换成新的字符串
- public String[] split(String str):根据str做拆分
- public String substring(int beginIndex, int endIndex)：截取父字符串的一部分，结尾参数可去掉
public class Demo02 {

    public static void main(String[] args) {

        //1. length()：返回字符串的长度
        //2. charAt(int index)：根据下标获取字符
        //3. contains(String str)：判断当前字符串是否包含str

        String s = "java是世界上最好的语言";
        System.out.println(s.length());//13
        System.out.println(s.charAt(0));//首位字符 j
        System.out.println(s.charAt(s.length()-1));//末尾字符 言
        System.out.println(s.contains("java"));//true
        System.out.println(s.contains("Php"));//false

        //4. toCharArray()：将字符串转化为数组
        //5. indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
        //6. lastIndexOf(String str)：查找str最后一次出现的下标索引

        System.out.println(Arrays.toString(s.toCharArray()));//[j, a, v, a, 是, 世, 界, 上, 最, 好, 的, 语, 言]
        System.out.println(s.indexOf("a"));//1
        System.out.println(s.lastIndexOf("a"));//3

        //7. trim()：去掉字符串前后的空格
        //8. toUpperCase()：将小写转成大写
        //9. endWith(String str)：判断字符串是否以str结尾

        String s2 = "  asd   ";

        String s3 = s2.trim();
        System.out.println(s3);//asd

        String s4 = s3.toUpperCase();
        System.out.println(s4);//ASD 转为大写字母

        String s5 = s4.toLowerCase();
        System.out.println(s5);//asd 转为小写字母

        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//true

        //10. replace(char oldChar,char newChar):将旧字符串替换成新的字符串
        //11. split(String str):根据str做拆分

        System.out.println("==========");
        System.out.println(s.replace("java","php"));

        String s1 = "java is the best  language of the world,  java is good";
        String[] arr = s1.split("[ ,]+");//[ ,]表示以空格或者逗号作为分隔符，+表示空格和逗号可以出现多次
        System.out.println(arr.length);//11
        for (String s6 : arr) {
            System.out.println(s6);

        }
        //字符串String的split方法, 传入的分隔字符串是正则表达式!
        // 部分关键字(比如.[]()\|等)需要转义
        String str = "a.ab.abc";
        String str1 = "a|ab|abc";
        System.out.println(Arrays.toString(str.split("\\.")));//[a, ab, abc]
        System.out.println(Arrays.toString(str1.split("\\|")));//[a, ab, abc]

        //补充:equals,compareTo()
        System.out.println("---------------");
        String s6 = "hello";
        String s7 = "Hello";
        System.out.println(s6.equalsIgnoreCase(s7));//true 忽略大小写

        String s8 = "abc";//97
        String s9 = "xyz";//120
        System.out.println(s8.compareTo(s9));//-23

        String s10 = "abc";//3
        String s11 = "abcxyz";//6
        System.out.println(s10.compareTo(s11));//-3,比较长度

    }
}
折叠 
public class TestDemo02 {

    public static void main(String[] args) {

        String str = "this is a text";
        //1.将str中的单词单独获取出来
        String[] arr = str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        //2.将str中的text替换为practice
        String str2 = str.replace("text", "practice");
        System.out.println(str2);

        //3.在text前面插入一个easy
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);

        //4.将每个单词的首字母该为大写
        //substring截取父字符串的一部分
        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);

        }
    }
}

(2)StringBuffer和StringBuilder

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

public class Demo03 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        //1. append(); 追加
        sb.append("张三");
        System.out.println(sb.toString());
        sb.append("李四");
        System.out.println(sb.toString());
        sb.append("王五");
        System.out.println(sb.toString());
        //2. insert(); 添加
        sb.insert(0, "第一");
        System.out.println(sb.toString());
        //3. replace(); 替换
        sb.replace(0,2,"第二");
        System.out.println(sb.toString());
        //4. delete(); 删除
        sb.delete(0,2);
        System.out.println(sb.toString());
    }
}
//测试StringBuilder和String的速度
public class TestDemo03 {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

//        String string = "";
//        for (int i = 0; i < 99999; i++) {
//            string += i;
//        }
//        System.out.println(string);//28791 String用时28.791秒

        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            stringBuilder.append(i);
        }
        System.out.println(stringBuilder);//74 StringBuilder用时0.074秒,速度比String快太多了

        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));

    }

}

4.BigDecimal

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

public class Demo01 {

    public static void main(String[] args) {

        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1 - d2);

        //面试题
        double result = (1.4-0.5)/0.9;
        System.out.println(result);

        //BigDecimal 大的浮点数的精确计算
        BigDecimal bd = new BigDecimal("1.0");
        BigDecimal bd1 = new BigDecimal("0.9");

        //加法
        BigDecimal r1 = bd.add(bd1);
        System.out.println(r1);

        //减法
        BigDecimal r = bd.subtract(bd1);
        System.out.println(r);

        //乘法
        BigDecimal r2 = bd.multiply(bd1);
        System.out.println(r2);

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

        BigDecimal result2 = new BigDecimal("20").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(result2);
        //除法：divide(BigDecimal bd, int scale, RoundingMode mode)
        //参数scale：指定精确到小数点后几位
        //参数mode：指定小数部分的取舍模式，通常采用四舍五入模式，取值为BigDecimal.ROUND_HALF_UP
    }
}
折叠 

5. Date

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

public class Demo01 {

    public static void main(String[] args) {

        //1.创建Date对象
        Date date = new Date();
        System.out.println(date.toString());
        System.out.println(date.toLocaleString());

        Date date1 = new Date(date.getTime()-(60*60*24*1000));
        System.out.println(date1.toLocaleString());

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

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

        //equals()
        boolean b = date.equals(date1);
        System.out.println(b);
    }
}

6. Calendar

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

public class Demo01 {

    public static void main(String[] args) {

        //1. 创建Calendar
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2. 获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //月
        int month = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//DATE
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY 24h,HOUR 12h
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "-" +
                (month+1) + "-" +
                day + " " +
                hour + ":" +
                minute + ":" +
                second);
        //3. 修改时间 set
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 23);//日期变为23号
        System.out.println(calendar1.getTime().toLocaleString());

        //4. 修改时间 add
        calendar1.add(Calendar.HOUR, -1);//减少一小时
        System.out.println(calendar1.getTime().toLocaleString());

        //5. 补充方法
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);//计算本月最大天数
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);//计算本月最小天数
        System.out.println(max);
        System.out.println(min);
    }
}
折叠 

7.SimpleDateFormat

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

字母	日期或时间	示例
y	年	2021
M	年中月份	02
d	月中天数	24
H	1天中小时数（0~23）	11
m	分钟	46
s	秒	59
S	毫秒	345

public class Demo01 {

    public static void main(String[] args) throws ParseException {

        //1. 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2. 创建Date
        Date date = new Date();
        //格式化date(日期转字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //解析（字符串转时间）
        Date date1 = sdf.parse("2021年02月24日 12:05:42");
        System.out.println(date1);
    }
}

8. System

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

	static void arraycopy(...)	//1.复制数组
	static long currentTimeMillis();//2.获取当前系统时间，返回的是毫秒值
	static void gc();//3.建议JVM赶快启动垃圾回收器回收垃圾
	static void exit(int status);//4.退出JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM
public class Demo01 {

    public static void main(String[] args) {

        //1. 数组的复制arraycopy
        //src:源数组
        //srcPos：从哪个位置开始复制0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] array = new int[]{2,4,6,8,10};
        int[] dest = new int[5];
        System.arraycopy(array,4,dest,2,1);
        for (int d : dest) {
            System.out.println(d);
        }

        //2. 获取当前系统时间，返回的是毫秒值currentTimeMillis();
        long start = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            stringBuilder.append(i);
        }
        System.out.println(stringBuilder);//74 StringBuilder用时0.074秒,速度比String快太多了

        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));

        //3. 建议JVM赶快启动垃圾回收器回收垃圾gc();
        new Student("a", 20);
        new Student("b", 20);
        new Student("c", 20);
        new Student("d", 20);
        new Student("e", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");

        //4. 退出JVM exit();
        System.exit(0);
        System.out.println("程序结束了......");
    }
}

标签：常用,内部,17,System,String,println,new,public,out
来源： https://www.cnblogs.com/spyX/p/16446964.html